// Sequelize ORM框架中文封装
const Sequelize = require('sequelize');

/**
 * 创建数据库连接
 * @param {string} 数据库名称 - 数据库名
 * @param {string} 用户名 - 数据库用户名
 * @param {string} 密码 - 数据库密码
 * @param {Object} 配置 - 连接配置选项
 * @returns {Sequelize} Sequelize实例
 */
function 创建连接(数据库名称, 用户名, 密码, 配置) {
  return new Sequelize(数据库名称, 用户名, 密码, 配置);
}

/**
 * 定义模型
 * @param {Sequelize} 连接实例 - Sequelize连接实例
 * @param {string} 模型名称 - 模型名称
 * @param {Object} 属性 - 模型属性定义
 * @param {Object} 选项 - 模型选项
 * @returns {Model} Sequelize模型
 */
function 定义模型(连接实例, 模型名称, 属性, 选项) {
  if (!选项) {
    选项 = {};
  }
  return 连接实例.define(模型名称, 属性, 选项);
}

/**
 * 同步数据库模型
 * @param {Sequelize} 连接实例 - Sequelize连接实例
 * @param {Object} 选项 - 同步选项
 * @returns {Promise} 同步结果Promise
 */
function 同步数据库(连接实例, 选项) {
  if (!选项) {
    选项 = {};
  }
  return 连接实例.sync(选项);
}

/**
 * 强制同步数据库（删除并重建表）
 * @param {Sequelize} 连接实例 - Sequelize连接实例
 * @returns {Promise} 同步结果Promise
 */
function 强制同步数据库(连接实例) {
  return 连接实例.sync({ force: true });
}

/**
 * 自动迁移数据库
 * @param {Sequelize} 连接实例 - Sequelize连接实例
 * @returns {Promise} 迁移结果Promise
 */
function 自动迁移(连接实例) {
  return 连接实例.sync({ alter: true });
}

/**
 * 关闭数据库连接
 * @param {Sequelize} 连接实例 - Sequelize连接实例
 * @returns {Promise} 关闭结果Promise
 */
function 关闭连接(连接实例) {
  return 连接实例.close();
}

/**
 * 测试数据库连接
 * @param {Sequelize} 连接实例 - Sequelize连接实例
 * @returns {Promise} 连接测试结果Promise
 */
function 测试连接(连接实例) {
  return 连接实例.authenticate();
}

/**
 * 创建事务
 * @param {Sequelize} 连接实例 - Sequelize连接实例
 * @param {Object} 选项 - 事务选项
 * @returns {Promise<Transaction>} 事务对象Promise
 */
function 创建事务(连接实例, 选项) {
  if (!选项) {
    选项 = {};
  }
  return 连接实例.transaction(选项);
}

/**
 * 查询数据库中的所有表
 * @param {Sequelize} 连接实例 - Sequelize连接实例
 * @returns {Promise<Array>} 表信息数组
 */
function 获取所有表(连接实例) {
  return 连接实例.showAllSchemas();
}

/**
 * 为模型添加关联
 * @param {Model} 源模型 - 源模型
 * @param {Model} 目标模型 - 目标模型
 * @param {string} 关联类型 - 关联类型（一对一/一对多/多对一/多对多）
 * @param {Object} 选项 - 关联选项
 */
function 添加关联(源模型, 目标模型, 关联类型, 选项) {
  if (!选项) {
    选项 = {};
  }
  
  let 关联方法;
  switch (关联类型) {
    case '一对一':
      关联方法 = 'hasOne';
      break;
    case '一对多':
      关联方法 = 'hasMany';
      break;
    case '多对一':
      关联方法 = 'belongsTo';
      break;
    case '多对多':
      关联方法 = 'belongsToMany';
      break;
    default:
      throw new Error('不支持的关联类型: ' + 关联类型);
  }
  
  return 源模型[关联方法](目标模型, 选项);
}

/**
 * 创建查询构建器
 * @param {Model} 模型 - Sequelize模型
 * @returns {QueryBuilder} 查询构建器
 */
function 创建查询构建器(模型) {
  return 模型.build();
}

/**
 * 查询所有记录
 * @param {Model} 模型 - Sequelize模型
 * @param {Object} 选项 - 查询选项
 * @returns {Promise<Array>} 记录数组
 */
function 查询所有(模型, 选项) {
  if (!选项) {
    选项 = {};
  }
  return 模型.findAll(选项);
}

/**
 * 根据ID查询记录
 * @param {Model} 模型 - Sequelize模型
 * @param {any} id - 记录ID
 * @param {Object} 选项 - 查询选项
 * @returns {Promise<Model>} 记录对象
 */
function 根据ID查询(模型, id, 选项) {
  if (!选项) {
    选项 = {};
  }
  return 模型.findByPk(id, 选项);
}

/**
 * 创建记录
 * @param {Model} 模型 - Sequelize模型
 * @param {Object} 数据 - 记录数据
 * @param {Object} 选项 - 创建选项
 * @returns {Promise<Model>} 创建的记录
 */
function 创建记录(模型, 数据, 选项) {
  if (!选项) {
    选项 = {};
  }
  return 模型.create(数据, 选项);
}

/**
 * 批量创建记录
 * @param {Model} 模型 - Sequelize模型
 * @param {Array} 数据数组 - 记录数据数组
 * @param {Object} 选项 - 创建选项
 * @returns {Promise<Array>} 创建的记录数组
 */
function 批量创建(模型, 数据数组, 选项) {
  if (!选项) {
    选项 = {};
  }
  return 模型.bulkCreate(数据数组, 选项);
}

/**
 * 更新记录
 * @param {Model} 模型 - Sequelize模型
 * @param {Object} 更新数据 - 更新数据
 * @param {Object} 选项 - 更新选项（包含where条件）
 * @returns {Promise<Array>} 更新结果
 */
function 更新记录(模型, 更新数据, 选项) {
  if (!选项) {
    选项 = {};
  }
  return 模型.update(更新数据, 选项);
}

/**
 * 删除记录
 * @param {Model} 模型 - Sequelize模型
 * @param {Object} 选项 - 删除选项（包含where条件）
 * @returns {Promise<number>} 删除的记录数
 */
function 删除记录(模型, 选项) {
  if (!选项) {
    选项 = {};
  }
  return 模型.destroy(选项);
}

/**
 * 计算记录总数
 * @param {Model} 模型 - Sequelize模型
 * @param {Object} 选项 - 查询选项
 * @returns {Promise<number>} 记录总数
 */
function 计数(模型, 选项) {
  if (!选项) {
    选项 = {};
  }
  return 模型.count(选项);
}

/**
 * 获取Sequelize原始模块
 * @returns {Object} Sequelize原始模块
 */
function 获取原始Sequelize() {
  return Sequelize;
}

// 数据类型定义
const 数据类型 = {
  字符串: Sequelize.STRING,
  文本: Sequelize.TEXT,
  整数: Sequelize.INTEGER,
  浮点数: Sequelize.FLOAT,
  双精度: Sequelize.DOUBLE,
  十进制: Sequelize.DECIMAL,
  布尔值: Sequelize.BOOLEAN,
  日期: Sequelize.DATE,
  日期时间: Sequelize.DATE,
  UUID: Sequelize.UUID,
  JSON: Sequelize.JSON,
  JSONB: Sequelize.JSONB,
  数组: Sequelize.ARRAY,
  枚举: Sequelize.ENUM,
  大整数: Sequelize.BIGINT,
  二进制: Sequelize.BLOB
};

// 查询操作符
const 操作符 = {
  等于: Sequelize.Op.eq,
  不等于: Sequelize.Op.ne,
  大于: Sequelize.Op.gt,
  大于等于: Sequelize.Op.gte,
  小于: Sequelize.Op.lt,
  小于等于: Sequelize.Op.lte,
  或: Sequelize.Op.or,
  与: Sequelize.Op.and,
  不在: Sequelize.Op.notIn,
  在: Sequelize.Op.in,
  喜欢: Sequelize.Op.like,
  不喜欢: Sequelize.Op.notLike,
  包含: Sequelize.Op.contains,
  被包含: Sequelize.Op.overlap,
  为空: Sequelize.Op.is,
  不为空: Sequelize.Op.not
};

// 关联类型
const 关联类型 = {
  一对一: 'hasOne',
  一对多: 'hasMany',
  多对一: 'belongsTo',
  多对多: 'belongsToMany'
};

module.exports = {
  // 主要功能函数
  创建连接,
  定义模型,
  同步数据库,
  强制同步数据库,
  自动迁移,
  关闭连接,
  测试连接,
  创建事务,
  获取所有表,
  添加关联,
  创建查询构建器,
  
  // 查询方法
  查询所有,
  根据ID查询,
  创建记录,
  批量创建,
  更新记录,
  删除记录,
  计数,
  
  // 工具函数
  获取原始Sequelize,
  
  // 常量定义
  数据类型,
  操作符,
  关联类型,
  
  // 版本信息
  版本: '1.0.0',
  Sequelize版本: Sequelize.version
};